/**
 * <p>隐藏框</p>
 * 
 * @class 隐藏框控件类
 */
zxt.ui.Hidden = function() {
	zxt.ui.Element.call(this);
	this._$input = $("<input type=\"hidden\"/>");
	this._$jqDom = $("<div nowrap class='zxt-Element'>");
};

/**
 * <p>根据传入的DOM元素, 解析传入的相关属性, 创建相应的隐藏框对象</p>
 * 
 * @function
 * @static
 * @param {DOM} elem 解析的DOM元素
 * @return {zxt.ui.Hidden} 根据传入的DOM元素创建的隐藏框对象
 */
zxt.ui.Hidden.parse = function(elem) {
	var j = $(elem);

	var _val = j.attr("zxt.value");
	
	var _instance = new zxt.ui.Hidden();

	_instance.val(_val);
	return _instance;
};

zxt.defineClazz(zxt.ui.Hidden, zxt.ui.Element);

/**
 * <p>返回控件类型</p>
 * 
 * @function
 * @returns {string} "Hidden"
 */
zxt.ui.Hidden.prototype.getType = function() {
	return "zxt.ui.Hidden";
};


/**
 * <p>
 * 渲染该隐藏框的DOM节点
 * </p>
 * 
 * @function
 * @return {DOM} 渲染成的DOM节点
 */
zxt.ui.Hidden.prototype.renderSelf = function() {
	var content = this.val() || '';
	this._$input.val(content);
	this._$jqDom.empty();
	this._$jqDom.append(this._$input);
	return this._$jqDom.get(0);
};



/**
 * <p>返回值</p>
 * 
 * @function
 * @returns {string} 设置的值
 */
zxt.ui.Hidden.prototype.getSelfValue = function() {
	if ( zxt.util.isAvailable(this.val()) ){
		return this.val();
	}
	
	return "";
};

/**
 * <p>[LABEL]模式下的显示字符串</p>
 * 
 * @function
 * @return [LABEL]模式下的显示字符串
 */
zxt.ui.Hidden.prototype.getSelfLabel = function() {
	return "";
};

/**
 * [MASK]模式下的显示字符串
 * 
 * @function
 * @return [MASK]模式下的显示字符串
 */
zxt.ui.Hidden.prototype.getMask = function() {
	return "";
};

/**
 * <p>获得焦点方法</p>
 * @return {int} -1
 */
zxt.ui.Hidden.prototype.focus = function(){
	return -1;
};

/**
 * <p>失去焦点方法</p>
 * @return {int} -1
 */
zxt.ui.Hidden.prototype.blur = function(){
	return -1;
};

/**
 * <p>隐藏控件工厂类</p>
 * @class 
 */
zxt.ui.HiddenFactory = function() {
};

zxt.defineClazz(zxt.ui.HiddenFactory, zxt.ui.InteractorFactory);

/**
 * <p>获取相应的隐藏控件实例对象</p>
 * 
 * @function
 * @return {zxt.ui.Hidden} 输入框实例对象
 */
zxt.ui.HiddenFactory.prototype.getInstance = function() {
	return new zxt.ui.Hidden();
};



/**
 * <p>该类表示一个简单的按钮控件, 该按钮支持的特性包括了</p>
 * <ul>
 * <li>支持定制单击事件</li>
 * <li>支持灰化状态</li>
 * <li>支持隐藏状态</li>
 * </ul>
 * 
 * @class 表示一个按钮对象
 * @param {string} label 按钮的标签
 * @param {string} [text] 按钮的显示文本, 未指定时使用传入的标签作为显示
 */
zxt.ui.Button = function(label, text) {
	zxt.ui.Widget.call(this);

	this._label = label;
	this._text = text || label;
	this._clickFunc = null;
	this._validateFunc = null;
	this._tablePanel = new zxt.ui.TablePanel(1, 3);
	this._$jqDom = null;
	this.VALIDATE = false;
};

/**
 * <p>根据传入的DOM元素, 解析传入的相关属性, 创建相应的按钮对象</p>
 * 
 * @function
 * @static
 * @param {DOM} elem 解析的DOM元素
 * @return {zxt.ui.Button} 根据传入的DOM元素创建的按钮对象
 */
zxt.ui.Button.parse = function(elem) {
	var j = $(elem);

	var _label = j.attr("zxt.label");
	var _text = j.attr("zxt.text");
	
	var _id = j.attr("id");
	var _fun = "onClick$" + _id;
	var _vfun = "validate$" + _id;
	var _clickFunc = window[_fun];
	var _validateFunc = window[_vfun];
	var _enabled = j.attr("zxt.enabled") == false || j.attr("zxt.enabled") == "false"? false : true;
	var _instance = new zxt.ui.Button(_label, _text);
	_instance._enabled = _enabled;
	_instance.VALIDATE = j.attr("zxt.validate");
	_instance._validateFunc = _validateFunc;
	if (zxt.util.isFunction(_clickFunc)) {
		_instance._clickFunc = _clickFunc;
	};
	return _instance;
};

zxt.defineClazz(zxt.ui.Button, zxt.ui.Widget);

/**
 * <p>
 * 返回按钮的控件类型
 * </p>
 * 
 * @function
 * @returns {string} "zxt.ui.Button"
 */
zxt.ui.Button.prototype.getType = function() {
	return "zxt.ui.Button";
};

/**
 * <p>
 * 返回按钮的标签
 * </p>
 * 
 * @function
 * @returns {string} 该按钮的标签
 */
zxt.ui.Button.prototype.label = function() {
	return this._label;
};

/**
 * <p>按钮的显示模式</p>
 * @param {String} v 按钮的模式
 * @return {String} 按钮的模式
 */
zxt.ui.Button.prototype.mode = function(v){
	if(v===undefined){
		if ( zxt.util.isValue(this._mode) ){
			return this._mode;
		} else {
			var parent = this.getParent();
			if ( zxt.util.isValue(parent) ){
				var parentmode = this.getParent().mode();
				if(parentmode =="LABEL"||parentmode == "MASK"){
					return this._mode;
				};
				return parentmode;
			};
			return null;
		};
	};
	if(v=="LABEL"||v=="MASK"){
		return;
	};
	this._mode = v;
};
/**
 * <p>[GETTER | SETTER] 按钮显示文字</p>
 * @function
 * @param {String}   v 描述
 * @return {String} 参数没有上送，则返回当前的按钮描述      
 */
zxt.ui.Button.prototype.text = function(v) {
	if (v === undefined) {	return this._text;	}
  this._text = v;
};

/**
 * <p>按钮Click方法</p>
 * @param {function} v 方法
 * @return {function} 参数没有上送，则返回当前的Click方法
 */
zxt.ui.Button.prototype.clickFunc = function(v) {
	if (v === undefined) { return this._clickFunc; };
	this._clickFunc = v;
};

/**
 * <p>按钮触发的校验方法</p>
 * @param  {function} v 方法
 * @return {function} 参数没有上送，则返回当前的validate方法
 */
zxt.ui.Button.prototype.validateFunc = function(v) {
	if (v === undefined) { return this._validateFunc; };
	this._validateFunc = v;
};

/**
 * <p>
 * 渲染该按钮的DOM节点
 * </p>
 * 
 * @function
 * @return {DOM} 渲染成的DOM节点
 */
zxt.ui.Button.prototype.renderSelf = function() {
	var host = this;

	if( !zxt.util.isValue(this._$jqDom) ){
		var panelDom = this._tablePanel.render();	
		$(panelDom).addClass("adaptive");
		$(this._tablePanel.getCell(0, 0)).addClass("zxt-LButton");
		$(this._tablePanel.getCell(0, 1)).addClass("zxt-CButton");
		$(this._tablePanel.getCell(0, 2)).addClass("zxt-RButton");			
		$(this._tablePanel.getCell(0, 1)).addClass("zxt-CButton").text(this._text);
		
		this._$jqDom = $("<div class='zxt-Element'>");
		if ( system.isFF ){
			$(panelDom).attr("tabindex", "-1");
			$(panelDom).focus( function(e) {host.onDomFocus(e);} ).blur( function(e) {host.onDomBlur(e);} );
		} else if( system.isIE ){
			this._tablePanel.getCell(0, 1).onfocus=function(e){ host.onDomFocus(e); };
			this._tablePanel.getCell(0, 1).onblur=function(e){ host.onDomBlur(e); };
		};
		this._$jqDom.append(panelDom);
	} else {
		$(this._tablePanel.getCell(0, 1)).text(this._text);
	};
	
	if(this.mode() == "DISABLE" ){
		$(this._tablePanel.getCell(0, 1)).addClass("zxt-CButton").addClass("zxt-Button-disabled").unbind();
	}else{
		$(this._tablePanel.getCell(0, 1)).unbind();
		$(this._tablePanel.getCell(0, 1)).addClass("zxt-CButton").removeClass("zxt-Button-disabled").click(function(e) {host.onClick(e);});
	};
	return this._$jqDom.get(0);
};

/**
 * <p>按钮的点击事件处理, 可以重设该函数来定制单击事件逻辑.</p>
 * 
 * @function
 * @param {Event} e 事件(未启用)
 */
zxt.ui.Button.prototype.onClick = function(e) {
	this.onFocus();
	var btnId = this.id();	
	
	if (zxt.util.isAvailable(btnId)) {
		zxt.Page.INSTANCE.event("onClick", btnId);		
	}
	if (zxt.util.isFunction(this._clickFunc)) {			
			this._clickFunc.call(this);
	};
	//e.stopPropagation();
};

zxt.ui.Button.prototype.onDomFocus = function(e) {
};

zxt.ui.Button.prototype.onDomBlur = function(e) {
	this.blur();
};

/**
 * <p>设置焦点</p>
 * @function
 * @return {int} 如果已经获得焦点或显示模式为DISABLE/LABEL/MASK，返回0；否则，返回1
 */
zxt.ui.Widget.prototype.focus = function(){
	if ( this._focused == 1 ){
		return 0;
	};
	if (this.mode() == "DISABLE"||this.mode()=="LABEL"||this.mode()=="MASK"){
		return 0;
	};
	this.focusSelf();
	this.onFocus();
	return 1;
};	

/**
 * <p>设置当前控件焦点</p>
 * 

 * @function
 * @returns
 */
zxt.ui.Button.prototype.focusSelf = function(){
	$(this._tablePanel.renderedDOM()).focus();
};

zxt.ui.Button.prototype.whenFocus = function(){
	$(this._tablePanel.getCell(0, 0)).removeClass("zxt-LButton").addClass("zxt-LButtonFocus");
	$(this._tablePanel.getCell(0, 1)).removeClass("zxt-CButton").addClass("zxt-CButtonFocus");
	$(this._tablePanel.getCell(0, 2)).removeClass("zxt-RButton").addClass("zxt-RButtonFocus");	
};	

/**

 * <p>失去当前控件焦点</p>
 * 
 * @function
 * @returns
 */
zxt.ui.Button.prototype.blurSelf = function(){
	
};

zxt.ui.Button.prototype.whenBlur = function(){
	$(this._tablePanel.getCell(0, 0)).removeClass("zxt-LButtonFocus").addClass("zxt-LButton");
	$(this._tablePanel.getCell(0, 1)).removeClass("zxt-CButtonFocus").addClass("zxt-CButton");
	$(this._tablePanel.getCell(0, 2)).removeClass("zxt-RButtonFocus").addClass("zxt-RButton");
};	

/**
 * <p>键盘按键事件</p>
 * @function
 * @param event
 * @return
 */
zxt.ui.Button.prototype.onKeyDown = function(event){
	var keyCode = event.keyCode;
	switch(keyCode){
		case 13:	
			this.onClick();
			break;
	};
};

/**
 * <p>设置按钮的显示状态, 可以用来隐藏和显示该按钮.</p>
 * 
 * @function
 * @param {boolean} d  true - 显示按钮, false - 隐藏按钮
 */
zxt.ui.Button.prototype.setDisplay = function(d) {
	
};

/**
 * <p>返回按钮的显示状态</p>
 * 
 * @function
 * @returns {boolean} true - 显示状态, false - 隐藏状态
 */
zxt.ui.Button.prototype.isDisplay = function() {
	
};

/**
 * <p>提示控件</p>
 * @class
 * @extend zxt.ui.Widget
 * @param {String} val 提示内容
 */
zxt.ui.Prompt = function(val) {
	zxt.ui.Widget.call(this);
	this._text = val;
	this._$jqDom = $("<div nowrap class='zxt-Widget' style='white-space:nowrap;overflow:hidden'>");
};

/**
 * <p>根据传入的DOM元素, 解析传入的相关属性, 创建相应的隐藏框对象</p>
 * 
 * @function
 * @static
 * @param {DOM} elem 解析的DOM元素
 * @return {zxt.ui.Prompt} 根据传入的DOM元素创建的隐藏框对象
 */
zxt.ui.Prompt.parse = function(elem) {
	var j = $(elem);

	var _val = j.attr("zxt.text");
	
	var _instance = new zxt.ui.Prompt(_val);

	
	return _instance;
};

zxt.defineClazz(zxt.ui.Prompt, zxt.ui.Widget);

/**
 * <p>返回控件类型</p>
 * 
 * @function
 * @returns {string} "Prompt"
 */
zxt.ui.Prompt.prototype.getType = function() {
	return "zxt.ui.Prompt";
};

/**
 * <p>焦点设置</p>
 * @function
 * @return {int} 0
 */
zxt.ui.Prompt.prototype.focus = function() {
	return 0;
};

/**
 * <p>
 * 渲染该隐藏框的DOM节点
 * </p>
 * 
 * @function
 * @return {DOM} 渲染成的DOM节点
 */
zxt.ui.Prompt.prototype.renderSelf = function() {
	this._$jqDom.empty();
	var display = this._text || "&nbsp;";
	this._$jqDom.attr("Title",display);
	this._$jqDom.html(display);
	return this._$jqDom.get(0);
};


/**
 * <p>标签仅仅用来显示信息, 支持的特性包括</p>
 * <ul>
 * <li> 显示的映射: 不是直接显示设置的值, 而是值对应的映射; 譬如性别一栏Male显示"男", Female显示"女". </li>
 * </ul>
 * 
 * @class 标签控件类
 */
zxt.ui.Label = function() {	
	zxt.ui.AbstractSelect.call(this);
	zxt.ui.Element.call(this);

	this.$DefaultL = "";
	
	this._label = null;
	
	this._mapping = false;
	this.jqDom = null;
};

/**
 * <p>根据传入的DOM元素, 解析传入的相关属性, 创建相应的标签对象</p>
 * 
 * @function
 * @static
 * @param {DOM} elem 解析的DOM元素
 * @return {zxt.ui.Label} 根据传入的DOM元素创建的标签对象
 */
zxt.ui.Label.parse = function(elem) {
	var j = $(elem);

	var _val = j.attr("zxt.value");
	var _instance = new zxt.ui.Label();
	_instance.setValue(_val);
	
	var _hide = j.attr("zxt.hide") || "";	
	_instance.$Hide = _hide; 
		
	var _options = j.attr("zxt.options");	
	if ( zxt.util.isAvailable(_options) ){
		var options = zxt.util.cutStr(_options);	
		for(var i = 0;i<options.length;i++){
			_instance.addOption(options[i].value, options[i].label);
		};
		_instance._mapping = true;
	};
	
	$("div", j ).each( function( idx, dom )	{		
		var _option = $(dom).attr("zxt.option");
		var _service = $(dom).attr("zxt.service");
	
		if ( !zxt.util.isUndefined(_option) ){
			var _label = $(dom).attr("zxt.label");
			if ( _option == "*" ){
				_instance.$DefaultL = _label;
			} else {
				_instance.addOption(_option, _label);		
			};
		} else if ( !zxt.util.isUndefined(_service) ){
			var _method = $(dom).attr("zxt.method") || "query";
			var _param = $(dom).attr("zxt.param");
			
			var _tmodel = new zxt.data.TunnelTableModel(_service);
			_tmodel.method(_method);
			param = eval("(" + _param + ")");
			_tmodel.setParam(param);
			
			_instance.load(_tmodel);		
		};
		_instance._mapping = true;	
	});	
	
	return _instance;
};

zxt.defineClazz(zxt.ui.Label, zxt.ui.AbstractSelect, zxt.ui.Element);
zxt.ui.Label.prototype.getSelfLabel = zxt.ui.AbstractSelect.prototype.getSelfLabel;

/**
 * <p>返回控件类型</p>
 * 
 * @function
 * @returns {string} "zxt.ui.Label"
 */
zxt.ui.Label.prototype.getType = function() {
	return "zxt.ui.Label";
};

/**
 * <p>配置参数</p>
 * @param {Object} conf 配置项
 * @return
 */
zxt.ui.Label.prototype.conf = function(conf) {			
	if ( zxt.util.isValue(conf) ){
		var options = conf["_options"];
		this._mapping = true;
		if (zxt.util.isValue(options)) {
			for (var i=0; i < options.length; i++){
				if ( options[i].value == "*" ){
					this.$DefaultL = options[i].label;
				} else {
					this.addOption(options[i].value,options[i].label);		
				}
			}
		} else{
			this._options = conf["_options"];
		};
		
		this.config(conf);
	} else {
		this._mapping = false;
		this._options = null;
	};
};	

/**
 * <p>获取标签</p>
 * @param  {String} v 标签
 * @return 如果参数没有上传，则返回当前的标签设置
 */
zxt.ui.Label.prototype.label = function(v) {
	if (v === undefined) {	return this._label;	}
  this._label = v; 
};	

/**
 * <p>判断标签是否有映射的Option</p>
 * @function
 * @return {boolean} true:有 false:无
 */
zxt.ui.Label.prototype.mapped = function() {
	if ( this._mapping && zxt.util.isValue(this._options) ){
		var val = this.getValue();
		this._createLabels();	
		var opt = this.getOptionByValue(val);
		if ( zxt.util.isValue(opt) ){
			return true;			
		}
	};	
	return false;	
};	

/**
 * <p>获取标签值</p>
 * @function
 * @return {String} 标签值
 */ 
zxt.ui.Label.prototype.getSelfLabel = function() {
	var display = null;
		
	if ( zxt.util.isValue(this._label) ){
		display = this._label;
	} else if ( this._mapping && zxt.util.isValue(this._options) ){
		var val = this.getValue();
		this._createLabels();//zxt.ui.AbstractSelect.prototype._createLabels	
		var opt = this.getOptionByValue(val);
		if ( zxt.util.isValue(opt) ){
			display = this.getOptionText(opt);			
		} else {
			display = this._getDefaultLabel(val);
		}	
	} else {
		var val = this.getValue();
		display = val || "&nbsp;";
	};	
	
	return display;
};	

zxt.ui.Label.prototype._getDefaultLabel = function(v) {
	var vt = this.getValueText(v);	
	var lb = this.$DefaultL.replace("$VALUE$",vt);
	return lb;
}	

/**
 * <p>验证值的合法性</p>
 * 
 * @function
 * @returns {boolean} 标签验证永远返回true
 */
zxt.ui.Label.prototype.validate = function(value) {
	return true;
};

/**
 * <p>
 * 渲染该标签的DOM节点
 * </p>
 * 
 * @function
 * @return {DOM} 渲染成的DOM节点
 */
zxt.ui.Label.prototype.renderSelf = function() {	
	var display = this.getLabel();
	if (this.jqDom==null){
		this.jqDom = $("<div class='zxt-Label'>"  + display + "</div>")
	} else {
		this.jqDom.html(display);
	};
	return this.jqDom.get(0);
};

/**
 * <p>返回标签的HTML内容</p>
 * @function
 * @return {String} HTML内容
 */
zxt.ui.Label.prototype.html = function() {
	var display = this.getLabel();	
	return "<div class='zxt-Label'>"+ display +"</div>";
};

/**
 * <p>获取Value值</p>
 * @function
 * @return {String} Value值
 */
zxt.ui.Label.prototype.getSelfValue = function() {	
	var val = this.val();	
	if ( zxt.util.notValue(val) ){
		val = "";
	};
	return val;	
};

/**
 * <p>获取焦点</p>
 * @function
 * @return {int} 0
 */
zxt.ui.Label.prototype.focus = function() {
	return 0;
};

/**
 * <p>标签工厂类</p>
 * @class 标签工厂类
 */
zxt.ui.LabelFactory = function() {
	zxt.ui.InteractorFactory.call(this);	
};

zxt.defineClazz(zxt.ui.LabelFactory, zxt.ui.InteractorFactory);

/**
 * <p>获取相应的标签实例对象</p>
 * 
 * @function
 * @return 标签实例对象
 */
zxt.ui.LabelFactory.prototype.getInstance = function() {
	return new zxt.ui.Label();	
};


/**
 * <p>多选框</p>
 * 
 * @class 多选框控件类
 */
zxt.ui.Checkbox = function(cv, ucv) {
	zxt.ui.Element.call(this);
	
	this._jqDom = null;
	this._jqInner = null;
	this.listeners = new Array();
	
	this._yes = cv || true;
	this._no = ucv || false;
};

/**
 * 根据传入的DOM元素, 解析传入的相关属性, 创建相应的多选框对象
 * 
 * @function
 * @static
 * @param {DOM} elem 解析的DOM元素
 * @return {zxt.ui.Checkbox} 根据传入的DOM元素创建的多选框对象
 */
zxt.ui.Checkbox.parse = function(elem) {
	var j = $(elem);
	var _val = j.attr("zxt.value");
	var _ckval = j.attr("zxt.check");
	var _uckval = j.attr("zxt.uncheck");

	var _instance = new zxt.ui.Checkbox(_ckval, _uckval);

	if (!zxt.util.isUndefined(_val))
		_instance.setValue(_val);

	return _instance;
};

zxt.defineClazz(zxt.ui.Checkbox, zxt.ui.Element);

/**
 * 返回控件类型
 * 
 * @function
 * @returns {string} "zxt.ui.Checkbox"
 */
zxt.ui.Checkbox.prototype.getType = function() {
	return "zxt.ui.Checkbox";
};

zxt.ui.Checkbox.prototype.conf = function(conf) {
	if ( zxt.util.isAvailable(conf) ){
		this._yes = conf["check"];
		this._no = conf["uncheck"];
	}	
};	

/**
 * 验证值的合法性
 * 
 * @function
 * @returns {boolean} 返回true
 */
zxt.ui.Checkbox.prototype.validate = function(value) {
	return true;
};

/**
 * <p>
 * 渲染该多选框的DOM节点
 * </p>
 * 
 * @function
 * @return {DOM} 渲染成的DOM节点
 */
zxt.ui.Checkbox.prototype.renderSelf = function(value) {
	var host = this;
	
	if ( this._jqDom == null ){
		this._jqDom = $("<div nowrap style='display: inline;' class='zxt-Element'>");
	};

	var v = (this.val() == this._yes)? true : false;
	
	//初始化控件值
	if(this.val() == null){
		this.setValue(this._no);
	}
	
	//var check = $("<input type=checkbox>").attr("checked", v); ie6 NOT supported 
	var ckh = v?" checked":"";
	var check = $("<input type=checkbox "+ ckh +">");
	
	check.focus(function() {
		host.onFocus();
	});
	check.click(function() {
		host.clicked();
	});

	if (zxt.util.isAvailable(this.id()) && zxt.cfg.nameNative) {
		check.attr("name", this.id());
	};

	if(this.mode() == "DISABLE"){
		check.attr("disabled",true);
	}else{
		check.attr("disabled",false);
	};	

	this._jqInner = check;
	this._jqDom.empty();
	this._jqDom.append(this._jqInner);
	return this._jqDom.get(0);
};


/**
 * 返回该构件的输入值, 即多选框的选中状态
 * 
 * @function
 * @returns {boolean} 多选框的选中状态
 */
zxt.ui.Checkbox.prototype.beforeGetValue = function() {	
	if ( zxt.util.isValue(this._jqInner) ){
		this.val( this.checked()?this._yes:this._no );		
	};	
};

/**
 * 获取控件的显示字符串
 * 
 * @function
 * @return 控件的显示字符串
 */
zxt.ui.Checkbox.prototype.getSelfLabel = function() {
	var val = this.getValue();
	
	if ( !zxt.util.isValue(val) ){
		return "";
	};
	
	return val==this._yes?zxt.cfg.Checked:zxt.cfg.Unchecked;
};

/**
 * [MASK]模式下的显示字符串
 * 
 * @function
 * @return [MASK]模式下的显示字符串
 */
zxt.ui.Checkbox.prototype.getMask = function() {
	return "x";
};

/**
 * 返回该构件的输入值, 即多选框的选中状态
 * 
 * @function
 * @returns {boolean} 多选框的选中状态
 */
zxt.ui.Checkbox.prototype.checked = function() {
	var checked = this.getSelfValue();
	var ckval = ((!zxt.util.isAvailable(checked))||(checked != this._yes))?false:true;
	return ckval;
};	

/**
 * 增加多选框选中时的触发函数
 * 
 * @function
 * @param {function} fn 多选框选中时的触发函数
 */
zxt.ui.Checkbox.prototype.addListener = function(fn) {
	this.listeners.push(fn);
};

/**
 * 多选框的点击事件处理, 可以重设该函数来定制单击事件逻辑.
 * 
 * @event
 */
zxt.ui.Checkbox.prototype.clicked = function() {	
	var v = this.getSelfValue();
	if(v==this._yes){this.setValue(this._no);}
	else{this.setValue(this._yes);}
	
	for ( var k in this.listeners) {
		var fn = this.listeners[k];
		fn(this);
	};
};

zxt.ui.Checkbox.prototype.onKeyDown = function(keyCode){
		switch(keyCode)
		{
			case 13:	
        	  	this._jqInner.click();
				break;	
		}
};

/**
 * 设置当前控件焦点
 * 
 * @function
 * @returns {int} 0
 */
zxt.ui.Checkbox.prototype.focusSelf = function(){
	this._jqInner.focus();
	this._jqInner.addClass("zxt-focus");
};

/**
 * 失去当前控件焦点
 * 
 * @function
 * @returns {int} 0
 */
zxt.ui.Checkbox.prototype.blurSelf = function(){
	this._jqInner.blur();
	this._jqInner.removeClass("zxt-focus");
};

/**
 * <p>
 * 控件获得焦点事件
 * </p>
 * 
 * @private
 * @event
 */
/*zxt.ui.Checkbox.prototype.onFocus = function() {
	this._parent.setFocusState(this);
};*/


/**
 * <p>多选框工厂类</p>
 * @class 多选框工厂类
 */
zxt.ui.CheckboxFactory = function() {
	zxt.ui.InteractorFactory.call(this);
};

zxt.defineClazz(zxt.ui.CheckboxFactory, zxt.ui.InteractorFactory);

/**
 * <p>获取相应的多选框实例对象</p>
 * 
 * @function
 * @return 多选框实例对象
 */
zxt.ui.CheckboxFactory.prototype.getInstance = function() {	
	return new zxt.ui.Checkbox();
};

/**
 * <p>单选框</p>
 * 
 * @class 单选框控件类
 */
zxt.ui.Radiobox = function(group) {
	zxt.ui.Element.call(this);
	
	this._jqDom = null;
	this._jqInner = null;
	this._group = group;
	this.listeners = new Array();
};

/**
 * <p>根据传入的DOM元素, 解析传入的相关属性, 创建相应的单选框对象</p>
 * 
 * @function
 * @static
 * @param {DOM} elem 解析的DOM元素
 * @return {zxt.ui.Radiobox} 根据传入的DOM元素创建的单选框对象
 */
zxt.ui.Radiobox.parse = function(elem) {
	var j = $(elem);
	var _val = j.attr("zxt.value");
	var _group = j.attr("zxt.group");

	var _instance = new zxt.ui.Radiobox(_group);

	if (_val == "true") {
		_instance.setValue(true);
	} else {
		_instance.setValue(false);
	};

	return _instance;
};

zxt.defineClazz(zxt.ui.Radiobox, zxt.ui.Element);

/**
 * <p>返回控件类型</p>
 * 
 * @function
 * @returns {string} "zxt.ui.Radiobox"
 */
zxt.ui.Radiobox.prototype.getType = function() {
	return "zxt.ui.Radiobox";
};

/**
 * @private
 */
zxt.ui.Radiobox.prototype.conf = function(conf) {
	if ( zxt.util.notValue(conf) ) return;
	
	var _group = conf.group;
	if ( zxt.util.isValue(_group) ){
		this._group = _group;
	};	
};

/**
 * <p>验证值的合法性</p>
 * 
 * @function
 * @returns {boolean} 返回true
 */
zxt.ui.Radiobox.prototype.validate = function(value) {
	return true;
};

/**
 * <p>
 * 渲染该单选框的DOM节点
 * </p>
 * 
 * @function
 * @return {DOM} 渲染成的DOM节点
 */
zxt.ui.Radiobox.prototype.renderSelf = function() {
	var host = this;
	
	if ( this._jqDom == null ){
		this._jqDom = $("<div nowrap class='zxt-Element'>");
	};

	var v = this.val() || false;
	var group = "";
	if (zxt.util.isValue(this._group)) {
		group = " name='" + this._group + "'";
	};
	
	//var check = $("<input type='radio' " + group + "/>").attr("checked", v);
	var ckh = v? group+" checked":group;
	var check = $("<input type=radio "+ ckh +">");

	
	check.click(function() {
		host.clicked();
	});
	
	if(this.mode() == "DISABLE"){
		check.attr("disabled",true);
	}else{
		check.attr("disabled",false);
	};


	this._jqInner = check;
	this._jqInner.focus(function() {
		host.onFocus();
	});
	this._jqDom.empty();
	this._jqDom.append(this._jqInner);
	return this._jqDom.get(0);
};

/**
 * <p>返回该构件的输入值, 即单选框的选中状态</p>
 * 
 * @function
 * @returns {boolean} 单选框的选中状态
 */
zxt.ui.Radiobox.prototype.beforeGetValue = function() {	
	if ( zxt.util.isValue(this._jqInner) ){
		this.val( this.checked()?true:false );		
	};	
};

/**
 * <p>获取控件的显示字符串</p>
 * 
 * @function
 * @return {String} 控件的显示字符串
 */
zxt.ui.Radiobox.prototype.getSelfLabel = function() {
	var ck = this.getValue();
	if ( !zxt.util.isValue(ck) ){
		return "";
	};
	return ck?zxt.cfg.Checked:zxt.cfg.Unchecked;
};

/**
 * <p>[MASK]模式下的显示字符串</p>
 * 
 * @function
 * @return {String}[MASK]模式下的显示字符串:x
 */
zxt.ui.Radiobox.prototype.getMask = function() {
	return "x";
};

/**
 * <p>返回该构件的输入值, 即单选框的选中状态</p>
 * 
 * @function
 * @returns {boolean} 单选框的选中状态
 */
zxt.ui.Radiobox.prototype.checked = function(v) {
	if ( v == undefined ){	
		var checked = this._jqInner.attr("checked");
		var ckval = (zxt.util.isUndefined(checked)||(checked == false))?false:true;
		return ckval;
	}
	this._jqInner.attr("checked", v);	
};	

/**
 * <p>增加单选框选中时的触发函数</p>
 * 
 * @function
 * @param {function} fn 单选框选中时的触发函数
 */
zxt.ui.Radiobox.prototype.addListener = function(fn) {
	this.listeners.push(fn);
};

/**
 * <p>单选框的点击事件处理, 可以重设该函数来定制单击事件逻辑.</p>
 * 
 * @function
 */
zxt.ui.Radiobox.prototype.clicked = function() {
	this.getValue();
	for ( var k in this.listeners) {
		var fn = this.listeners[k];
		fn(this);
	};
};

/**
 * <p>键盘按下触发事件</p>
 * @param {int} keyCode 键盘按键的ASC编码
 * @return
 */
zxt.ui.Radiobox.prototype.onKeyDown = function(keyCode){
		switch(keyCode)
		{
			case 13:	//回车键
        	  				this._jqInner.click();
						break;	
		}
};

/**
 * <p>设置当前控件焦点</p>
 * 
 * @function
 * 
 */
zxt.ui.Radiobox.prototype.focusSelf = function(){
	this._jqInner.focus();
	this._jqInner.addClass("zxt-focus");
};

/**
 * <p>失去当前控件焦点</p>
 * 
 * @function
 * 
 */
zxt.ui.Radiobox.prototype.blurSelf = function(){
	this._jqInner.blur();
	this._jqInner.removeClass("zxt-focus");
};

/**
 * 
 * @private
 * @event
 */
/*zxt.ui.Radiobox.prototype.onFocus = function() {
	this._parent.setFocusState(this);
};*/


/**
 * <p>多选框工厂类</p>
 * @class 多选框工厂类
 */
zxt.ui.RadioboxFactory = function() {
};

zxt.defineClazz(zxt.ui.RadioboxFactory, zxt.ui.InteractorFactory);

/**
 * <p>获取相应的单选框实例对象</p>
 * 
 * @function
 * @return 单选框实例对象
 */
zxt.ui.RadioboxFactory.prototype.getInstance = function() {
	return new zxt.ui.Radiobox();
};




/**
 * <p>图片按钮</p>
 * 
 * @class 图片按钮控件类

 */
zxt.ui.Icon = function() {
	zxt.ui.Element.call(this);
	
	this._height = "100%";
	this._width = "100%";
	
	this._jqDom = null;
	this._jqInner = null;
	this._image = null;
	
};

/**

 * <p>根据传入的DOM元素, 解析传入的相关属性, 创建相应的单选框对象</p>
 * 
 * @function
 * @static
 * @param {DOM} elem 解析的DOM元素

 * @return {zxt.ui.Icon} 根据传入的DOM元素创建的单选框对象
 */
zxt.ui.Icon.parse = function(elem) {
	var j = $(elem);
	
	var _id = j.attr("id");
	var _fun = "onClick$" + _id;
	var _clickFunc = window[_fun];
	
	var _image = j.attr("zxt.image");
	
	var _instance = new zxt.ui.Icon() ;

	if (zxt.util.isFunction(_clickFunc)) {
		_instance._clickFunc = _clickFunc;
	};
	
	_instance.image(_image);

	return _instance;
};

zxt.defineClazz(zxt.ui.Icon, zxt.ui.Button);

/**
 * <p>返回控件类型</p>
 * 
 * @function
 * @returns {string} "zxt.ui.Radiobox"
 */
zxt.ui.Icon.prototype.getType = function() {
	return "zxt.ui.Icon";
};

/**
 * <p>高度</p>
 * @param {int} v 高度
 * @return {Object} 如果参数没有上传，则返回当前的高度设置；否则，返回当前对象
 */
zxt.ui.Icon.prototype.height = function(v){
	if(v===undefined){return this._height;}
	this._height = v;
	return this;
};

/**
 * <p>宽度</p>
 * @param {int} v 宽度
 * @return {Object} 如果参数没有上传，则返回当前的宽度设置；否则，返回当前对象
 */
zxt.ui.Icon.prototype.width = function(v){
	if(v===undefined){return this._width;}
	this._width = v;
	return this;
};

/**
 * <p>图片</p>
 * @param {Object} v 图片
 * @return {Object} 如果参数没有上传，则返回当前的图片；否则，返回当前对象
 */
zxt.ui.Icon.prototype.image = function(v){
	if(v===undefined){return this._image;}
	this._image = v;
	return this;
};


/**
 * <p>
 * 渲染该单选框的DOM节点
 * </p>
 * 
 * @function
 * @return {DOM} 渲染成的DOM节点
 */
zxt.ui.Icon.prototype.renderSelf = function() {
	var host = this;
	
	if ( this._jqDom == null ){
		this._jqDom = $("<div nowrap class='zxt-Element'>");
	} else {
		this._jqDom.empty();
	};
	
	var img = $("<img style='width:" + this._width + ";height:"+ this._height +"'/>");
	
	if (this._image) {
		img.attr("src",this._image);
	}
	
	if(this.mode() == "DISABLE"){
		img.css("cursor","auto");
	}else{
		img.css("cursor","pointer");
		img.click(function(e){host.onClick(e);});
	};

	this._jqInner = img;
	
	this._jqDom.append(this._jqInner);
	return this._jqDom.get(0);
};

zxt.ui.Icon.prototype.focusSelf = function(){
};

zxt.ui.Icon.prototype.blurSelf = function(){
};

zxt.ui.Icon.prototype.whenFocus = function(){
};

zxt.ui.Icon.prototype.whenBlur = function(){
};

zxt.ui.Icon.prototype.onKeyDown = function(event){
	var keyCode = event.keyCode;
	switch(keyCode){
		case 13:	
			this._clickFunc.call(this);
			break;	
	};
};

























